{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying noise to custom unitary gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "This notebook shows how to add custom unitary gates to a quantum circuit, and use them for noise simulations in Qiskit Aer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:18.154548Z",
     "start_time": "2019-08-19T17:09:15.909907Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import transpile, QuantumCircuit\n",
    "import qiskit.quantum_info as qi\n",
    "\n",
    "from qiskit_aer import AerSimulator\n",
    "from qiskit_aer.noise import NoiseModel, amplitude_damping_error\n",
    "\n",
    "from qiskit.visualization import plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating matrix operators\n",
    "\n",
    "We can use the `Operator` class in `qiskit.quantum_info` to represent arbitrary matrix operators. If the operator is unitary it can then be added to a quantum circuit and used for simulation on Qiskit Aer.\n",
    "\n",
    "Lets create two operators below for a CNOT gate and an iSWAP gate:\n",
    "\n",
    "$$\\mbox{CNOT} = \\left(\\begin{array} \n",
    "& 1 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & 1 \\\\ \n",
    "0 & 0 & 1 & 0 \\\\ \n",
    "0 & 1 & 0 & 0\n",
    "\\end{array}\\right), \\quad\n",
    "\\mbox{iSWAP} = \\left(\\begin{array} \n",
    "& 1 & 0 & 0 & 0 \\\\ \n",
    "0 & 0 & i & 0 \\\\ \n",
    "0 & i & 0 & 0 \\\\ \n",
    "0 & 0 & 0 & 1\n",
    "\\end{array}\\right)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:18.170527Z",
     "start_time": "2019-08-19T17:09:18.166252Z"
    }
   },
   "outputs": [],
   "source": [
    "# CNOT matrix operator with qubit-0 as control and qubit-1 as target\n",
    "cx_op = qi.Operator([[1, 0, 0, 0],\n",
    "                     [0, 0, 0, 1],\n",
    "                     [0, 0, 1, 0],\n",
    "                     [0, 1, 0, 0]])\n",
    "\n",
    "# iSWAP matrix operator\n",
    "iswap_op = qi.Operator([[1, 0, 0, 0],\n",
    "                        [0, 0, 1j, 0],\n",
    "                        [0, 1j, 0, 0],\n",
    "                        [0, 0, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** The matrix is specified with respect to the tensor product $U_{b}\\otimes U_{a}$ for qubits specified by list `[a, b]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using operators in circuits\n",
    "\n",
    "Let us demonstrate how these can be used in a circuit. We will consider an example of implementing a CNOT gate decomposed in terms of single-qubit gates and the iSWAP gate as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:55.343221Z",
     "start_time": "2019-08-19T17:09:55.332156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌─────┐     ┌────────┐┌─────┐┌───┐┌─────┐┌────────┐     \n",
      "q_0: ┤ SDG ├─────┤0       ├┤ SDG ├┤ H ├┤ SDG ├┤0       ├─────\n",
      "     ├─────┤┌───┐│  iswap │└─────┘└───┘└─────┘│  iswap │┌───┐\n",
      "q_1: ┤ SDG ├┤ H ├┤1       ├───────────────────┤1       ├┤ S ├\n",
      "     └─────┘└───┘└────────┘                   └────────┘└───┘\n"
     ]
    }
   ],
   "source": [
    "# CNOT in terms of iSWAP and single-qubit gates\n",
    "cx_circ = QuantumCircuit(2, name='cx<iSWAP>')\n",
    "\n",
    "# Add gates\n",
    "cx_circ.sdg(1)\n",
    "cx_circ.h(1)\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.unitary(iswap_op, [0, 1], label='iswap')\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.h(0)\n",
    "cx_circ.sdg(0)\n",
    "cx_circ.unitary(iswap_op, [0, 1], label='iswap')\n",
    "cx_circ.s(1)\n",
    "\n",
    "print(cx_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we have assigned an optional *label* of `\"iswap\"` to the unitary when it is inserted. This allows us to identify this unitary in a Qiskit Aer `NoiseModel` so that we can add errors to these custom unitary gates in noisy circuit simulations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can confirm this circuit returns the correct output using the `Operator` class as a simulator for the circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:09:58.954826Z",
     "start_time": "2019-08-19T17:09:58.948275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operator([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
      "          [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],\n",
      "          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
      "          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]],\n",
      "         input_dims=(2, 2), output_dims=(2, 2))\n"
     ]
    }
   ],
   "source": [
    "# Simulate the unitary for the circuit using Operator:\n",
    "unitary = qi.Operator(cx_circ)\n",
    "print(unitary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And to confirm the output is correct we can compute the average gate fidelity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:01.198369Z",
     "start_time": "2019-08-19T17:10:01.184222Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Gate Fidelity: F = 1.000000\n"
     ]
    }
   ],
   "source": [
    "f_ave = qi.average_gate_fidelity(cx_op, unitary)\n",
    "print(\"Average Gate Fidelity: F = {:f}\".format(f_ave))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a custom unitary in a noise model\n",
    "\n",
    "The Qiskit Aer `AerSimulator` supports simulation of arbitrary unitary operators directly as specified by the `\"unitary\"` in the basis gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:03.174651Z",
     "start_time": "2019-08-19T17:10:03.168643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'unitary' in AerSimulator().configuration().basis_gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows us to add noise models to arbitrary unitaries in our simulation when we identify them using the optional `label` argument of `QuantumCircuit.unitary`.\n",
    "\n",
    "We will now do this by creating a `NoiseModel` that includes a quantum error channel on our custom iSWAP gate. For our example we will create a 2-qubit error consisting of two single-qubit amplitude damping channels with different damping parameters. For now we will assume all the other circuit instructions are ideal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:05.585654Z",
     "start_time": "2019-08-19T17:10:05.574669Z"
    }
   },
   "outputs": [],
   "source": [
    "# Error parameters\n",
    "param_q0 = 0.05  # damping parameter for qubit-0\n",
    "param_q1 = 0.1   # damping parameter for qubit-1\n",
    "\n",
    "# Construct the error\n",
    "qerror_q0 = amplitude_damping_error(param_q0)\n",
    "qerror_q1 = amplitude_damping_error(param_q1)\n",
    "iswap_error = qerror_q1.tensor(qerror_q0)\n",
    "\n",
    "# Build the noise model by adding the error to the \"iswap\" gate\n",
    "noise_model = NoiseModel()\n",
    "noise_model.add_all_qubit_quantum_error(iswap_error, 'iswap')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when we add an error to a custom label such as `\"iswap\"` the `NoiseModel` does not know what gate this label is supposed to apply to, so we must manually add the desired gate string to the noise model `basis_gates`. This ensures that the compiler will unroll to the correct basis gates for the noise model simulation. This can done using the `NoiseModel.add_basis_gates` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:06.301854Z",
     "start_time": "2019-08-19T17:10:06.298595Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cx', 'id', 'u3', 'unitary']\n"
     ]
    }
   ],
   "source": [
    "noise_model.add_basis_gates(['unitary'])\n",
    "print(noise_model.basis_gates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the basis gates of a noise model are `['cx','id','u3']` plus any standard `AerSimulator` basis gates that are added to the noise model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating a custom unitary noise model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first take our previous CX circuit and add an initial Hadamard gate and final measurement to create a Bell-state preparation circuit that we may simulator on the `AerSimulator` both for the ideal and noisy case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:26.234163Z",
     "start_time": "2019-08-19T17:10:26.224218Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌───┐┌────────────┐┌─┐   \n",
      "q_0: ┤ H ├┤0           ├┤M├───\n",
      "     └───┘│  cx<iSWAP> │└╥┘┌─┐\n",
      "q_1: ─────┤1           ├─╫─┤M├\n",
      "          └────────────┘ ║ └╥┘\n",
      "c: 2/════════════════════╩══╩═\n",
      "                         0  1 \n"
     ]
    }
   ],
   "source": [
    "# Bell state circuit where iSWAPS should be inserted at barrier locations\n",
    "bell_circ = QuantumCircuit(2, 2, name='bell')\n",
    "bell_circ.h(0)\n",
    "bell_circ.append(cx_circ, [0, 1])\n",
    "bell_circ.measure([0,1], [0,1])\n",
    "print(bell_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideal output\n",
    "\n",
    "Let's first see the ideal output. Since this generates a Bell-state we expect two peaks for 00 and 11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:28.605669Z",
     "start_time": "2019-08-19T17:10:28.467516Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create ideal simulator backend and transpile circuit\n",
    "sim_ideal = AerSimulator()\n",
    "tbell_circ = transpile(bell_circ, sim_ideal)\n",
    "\n",
    "ideal_result = sim_ideal.run(tbell_circ).result()\n",
    "ideal_counts = ideal_result.get_counts(0)\n",
    "plot_histogram(ideal_counts,\n",
    "               title='Ideal output for iSWAP bell-state preparation')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Noisy circuit execution\n",
    "\n",
    "Finally, let's now simulate it with our custom noise model. Since there is a small amplitude damping error on the two-qubit gates we expect small additional peaks for the 01 and 10 outcome probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:31.078094Z",
     "start_time": "2019-08-19T17:10:30.946144Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create noisy simulator and transpile circuit\n",
    "sim_noise = AerSimulator(noise_model=noise_model)\n",
    "tbell_circ_noise = transpile(bell_circ, sim_noise)\n",
    "\n",
    "# Run on the simulator without noise\n",
    "noise_result = sim_noise.run(tbell_circ_noise).result()\n",
    "noise_counts = noise_result.get_counts(bell_circ)\n",
    "plot_histogram(noise_counts,\n",
    "               title='Noisy output for iSWAP bell-state preparation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-19T17:10:53.298595Z",
     "start_time": "2019-08-19T17:10:53.290949Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>0.25.0</td></tr><tr><td>Terra</td><td>0.17.0</td></tr><tr><td>Aer</td><td>0.8.0</td></tr><tr><td>Ignis</td><td>0.6.0</td></tr><tr><td>Aqua</td><td>0.9.0</td></tr><tr><td>IBM Q Provider</td><td>0.12.2</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.7 (default, May  6 2020, 04:59:01) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>6</td></tr><tr><td>Memory (Gb)</td><td>32.0</td></tr><tr><td colspan='2'>Fri Apr 02 12:12:41 2021 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2021.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit\n",
    "qiskit.__version__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
